package Model;

import java.io.IOException;
import java.sql.Date;
import java.util.LinkedList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

//import com.sun.org.apache.bcel.internal.generic.SALOAD;

import Control.*;
import Exceptions.AtributoInvalidoException;

/**
 * Esta classe eh responsavel por controlar todos os acessos as entidades
 * do banco de dados.
 * @author Arnaldo
 * @author Pablo Diego
 * @author Yuri Cariry 
 *
 */
public class XModel {
	protected XModel(){

	}

	private static XModel controlador = null;
	
	private ChegadaRecursoCRUD 		cadChegadaRecurso = ChegadaRecursoCRUD.getInstance() ; 
	private DepartamentoCRUD 		cadDepto = DepartamentoCRUD.getInstance();
	private GestaoCRUD 				cadGestao = GestaoCRUD.getInstance();
	private MovDepartamentoCRUD 	cadMovDepto = MovDepartamentoCRUD.getInstance();
	private MovGestaoCRUD 			cadMovGestao = MovGestaoCRUD.getInstance();
	private PermissoesCRUD 			cadPermissoes = PermissoesCRUD.getInstance();
	private RubricaCRUD 			cadRubrica = RubricaCRUD.getInstance();
	private RubricaDepartamentoCRUD cadRubDepto = RubricaDepartamentoCRUD.getInstance();

	private TipoMovimentoCRUD 		cadTipoMov = TipoMovimentoCRUD.getInstance();
	private TipoTransferenciaCRUD 	cadTipoTrans = TipoTransferenciaCRUD.getInstance();
	private TransferenciaCRUD 		cadTrans = TransferenciaCRUD.getInstance();
	private UsuariosCRUD 			cadUsuarios = UsuariosCRUD.getInstance();



	/**
	 * Zera todos os registros gravados no banco
	 */
	public void zerarSistema(){
		cadChegadaRecurso 		= ChegadaRecursoCRUD.getInstance();
		cadDepto			    = DepartamentoCRUD.getInstance();
		cadGestao 				= GestaoCRUD.getInstance();
		cadMovDepto				= MovDepartamentoCRUD.getInstance();
		cadMovGestao 			= MovGestaoCRUD.getInstance();
		cadPermissoes 			= PermissoesCRUD.getInstance();
		cadRubrica 				= RubricaCRUD.getInstance();
		cadRubDepto 			= RubricaDepartamentoCRUD.getInstance();
		cadTipoMov			    = TipoMovimentoCRUD.getInstance();
		cadTipoTrans 			= TipoTransferenciaCRUD.getInstance();
		cadTrans 				= TransferenciaCRUD.getInstance();
		cadUsuarios 			= UsuariosCRUD.getInstance();


		removeTodosChegadaRecurso();
		removeTodosDepartamentos();
		removeTodosGestaos();
		removeTodosMovDepartamentos();
		removeTodosMovGestaos();
		removeTodosPermissoess();
		removeTodosRubricaDepartamentos();
		removeTodosRubricas();
		removeTodosTipoMovimentos();
		removeTodosTipoTransferencias();
		removeTodosTransferencias();
		removeTodosUsuarios();
	}


	/**
	 * Recupera o controlador
	 * @return  Um controlador
	 */
	public static XModel getControlador() {
		return controlador;
	}

	/**
	 * Retorna um Controlador usando o construtor default
	 * @return controlador um Controlador
	 */
	public synchronized static XModel getInstance() {
		if(controlador == null)
			controlador = new XModel();
		return controlador;		
	}




	// TABELA 1 CHEGADA RECURSO

	public void cadastrarChegadaRecurso(int codigoChegadaRecurso,int  rubricaCodigoRubrica
			,int gestaoCodigoGestao, int codigoGestao
			,int codigoRubrica, String dataChegada
			,float dinheiro, String texto ) {

		ChegadaRecurso chegadaRecurso = new ChegadaRecurso();
		chegadaRecurso.setCodigoChegadaRecurso(codigoChegadaRecurso);
		chegadaRecurso.setCodigoGestao(codigoGestao);
		chegadaRecurso.setCodigoRubrica(codigoRubrica);
		chegadaRecurso.setDataChegada(dataChegada);
		chegadaRecurso.setDinheiro(dinheiro);
		chegadaRecurso.setGestaoCodigoGestao(gestaoCodigoGestao);
		chegadaRecurso.setRubricaCodigoRubrica(rubricaCodigoRubrica);
		chegadaRecurso.setTexto(texto);

		cadChegadaRecurso.salvaChegadaRecurso(chegadaRecurso);
	}



	public void removeChegadaRecurso(int cod) throws Exception {
		ChegadaRecurso c = procurarChegadaRecurso(cod);
		if(c == null)
			throw new Exception(" Nao encontrado.");
		else 
			cadChegadaRecurso.removeChegadaRecurso(c);
	}

	public ChegadaRecurso procurarChegadaRecurso(int cod) {
		List<ChegadaRecurso> listaChegadaRecurso = cadChegadaRecurso.getListaDeChegadaRecurso();
		for (ChegadaRecurso chegRec  : listaChegadaRecurso) {
			if (chegRec.getCodigoChegadaRecurso() != -1)
				if (chegRec.getCodigoChegadaRecurso() == cod ) {
					return chegRec; 
				}
		}
		return null;
	}


	public List<ChegadaRecurso> getListaDeChegadaRecurso() {
		return cadChegadaRecurso.getListaDeChegadaRecurso();
	}	

	public void removeTodosChegadaRecurso() {
		List<ChegadaRecurso> listaDeChegadaRecurso
		= cadChegadaRecurso.getListaDeChegadaRecurso();
		for (ChegadaRecurso chegadaRecurso : listaDeChegadaRecurso) {
			cadChegadaRecurso.removeChegadaRecurso(chegadaRecurso);
		}
	}


	public void AtualizarChegadaRecurso(int cod,int  rubricaCodigoRubrica
			,int gestaoCodigoGestao, int codigoGestao
			,int codigoRubrica, String dataChegada
			,float dinheiro, String texto ) {
		ChegadaRecurso chegRec = procurarChegadaRecurso(cod);
		chegRec.setCodigoChegadaRecurso(cod);
		chegRec.setCodigoGestao(codigoGestao);
		chegRec.setCodigoRubrica(codigoRubrica);
		chegRec.setDataChegada(dataChegada);
		chegRec.setDinheiro(dinheiro); 
		chegRec.setGestaoCodigoGestao(gestaoCodigoGestao);
		chegRec.setRubricaCodigoRubrica(rubricaCodigoRubrica);
		chegRec.setTexto(texto);
		cadChegadaRecurso.atualizarChegadaRecurso(chegRec);
	}


	public ChegadaRecurso getChegadaRecurso(int cod) {
		ChegadaRecurso chegRec = procurarChegadaRecurso(cod);
		return chegRec;
	}







	//tabela 2 DEPARTAMENTO  //	

	public void cadastrarDepartamento(int codigoDepartamento,String nomeDepartamento
			,String nomeChefe, String siglaDepartamento, String nomeSubChefe
			, String emailChefe, String emailSubChefe,String senhaUsuario
			, String telefoneChefe, String telefoneSubchefe, String faxChefe 
			, String faxSubChefe, String celularChefe, String celularSubChefe ) {

		Departamento depto = new Departamento();
		depto.setCelularChefe(celularChefe);
		depto.setCelularSubChefe(celularSubChefe);
		depto.setCodigoDepartamento(codigoDepartamento);
		depto.setEmailChefe(emailChefe);
		depto.setEmailSubChefe(emailSubChefe);
		depto.setFaxChefe(faxChefe);
		depto.setFaxSubChefe(faxSubChefe);
		depto.setNomeChefe(nomeChefe);
		depto.setNomeDepartamento(nomeDepartamento);
		depto.setNomeSubChefe(nomeSubChefe);
		depto.setSenhaUsuario(senhaUsuario);
		depto.setSiglaDepartamento(siglaDepartamento);
		depto.setTelefoneChefe(telefoneChefe);
		depto.setTelefoneSubchefe(telefoneSubchefe);

		cadDepto.salvaDepartamento(depto);
	}


	public void removeDepartamento(String nomeDepartamento) throws Exception{
		Departamento depto = procurarDepartamento(nomeDepartamento);
		if (depto == null)
			throw new Exception("depto nao encontrado.");
		else
			cadDepto.removeDepartamento(depto);
	}

	public Departamento procurarDepartamento(String nomeDepartamento) {
		List<Departamento> listaDepto = cadDepto.getListaDeDepartamento();
		for (Departamento depto : listaDepto) {
			if (depto.getNomeDepartamento() != null)
				if (depto.getNomeDepartamento().equals(nomeDepartamento)) {
					return depto; 
				}
		}
		return null;
	}




	public void removeTodosDepartamentos() {
		List<Departamento> listaDepartamentos = cadDepto.getListaDeDepartamento();
		for (Departamento depto : listaDepartamentos) {
			cadDepto.removeDepartamento(depto);
		}
	}




	public void atualizaDepartamento(int codigoDepartamento,String nomeDepartamento
			,String nomeChefe, String siglaDepartamento, String nomeSubChefe
			, String emailChefe, String emailSubChefe,String senhaUsuario
			, String telefoneChefe, String telefoneSubchefe, String faxChefe 
			, String faxSubChefe, String celularChefe, String celularSubChefe ) {

		Departamento depto = procurarDepartamento(nomeDepartamento);

		depto.setCelularChefe(celularChefe);
		depto.setCelularSubChefe(celularSubChefe);
		depto.setCodigoDepartamento(codigoDepartamento);
		depto.setEmailChefe(emailChefe);
		depto.setEmailSubChefe(emailSubChefe);
		depto.setFaxChefe(faxChefe);
		depto.setFaxSubChefe(faxSubChefe);
		depto.setNomeChefe(nomeChefe);
		depto.setNomeDepartamento(nomeDepartamento);
		depto.setNomeSubChefe(nomeSubChefe);
		depto.setSenhaUsuario(senhaUsuario);
		depto.setSiglaDepartamento(siglaDepartamento);
		depto.setTelefoneChefe(telefoneChefe);
		depto.setTelefoneSubchefe(telefoneSubchefe);

		cadDepto.atualizarDepartamento(depto);
	}



	public Departamento getDepartamento(int cod) {
		return cadDepto.getDepartamento(cod);
	}

	public List<Departamento> getListaDeDepartamento() {
		return cadDepto.getListaDeDepartamento();
	}

	public String getAtributoDepartamento(String nome, String atributo) throws Exception {
		Departamento depto = procurarDepartamento(nome);
		if(depto != null){

			if (atributo.equals("nomeChefe")) 
				return depto.getNomeChefe();
			else if (atributo.equals("siglaDepartamento"))
				return depto.getSiglaDepartamento();
			else if (atributo.equals("nomeSubChefe"))
				return depto.getNomeSubChefe();
			else if (atributo.equals("emailChefe"))
				return depto.getEmailChefe();
			else if (atributo.equals("emailSubChefe"))
				return depto.getEmailSubChefe();
			else if (atributo.equals("senhaUsuario"))
				return depto.getSenhaUsuario();
			else if (atributo.equals("telefoneChefe"))
				return depto.getTelefoneChefe();
			else if (atributo.equals("telefoneSubchefe"))
				return depto.getTelefoneSubchefe();
			else if (atributo.equals("faxChefe"))
				return depto.getFaxChefe();
			else if (atributo.equals("faxSubChefe"))
				return depto.getFaxSubChefe();
			else if (atributo.equals("celularChefe"))
				return depto.getCelularChefe();
			else if (atributo.equals("celularSubChefe"))
				return depto.getCelularSubChefe();
			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("Departamento nao encontrado.");
	}






	// TABELA 3 GESTAO


	public void cadastrarGestao(int codigoGestao,String nomeCentro
			,String nomeDiretor, String nomeViceDiretor, String siglaCentro
			, String nomeSecretarioGf, String emailDiretor,String emailViceDiretor
			, String emailSecretario, String texto, String ativa 
			, String faxDiretor, String faxViceDiretor, String faxSecretarioGf
			, String telefoneDiretor, String telefoneViceDiretor, String telefoneSecretarioGf
			, String celularDiretor, String celularViceDiretor, String celularSecretarioGf
			, String senhaUsuario	) {

		Gestao gestao = new Gestao();

		gestao.setAtiva(ativa);
		gestao.setCelularDiretor(celularDiretor);
		gestao.setCelularSecretarioGf(celularSecretarioGf);
		gestao.setCelularViceDiretor(celularViceDiretor);
		gestao.setCodigoGestao(codigoGestao);
		gestao.setEmailDiretor(emailDiretor);
		gestao.setEmailSecretario(emailSecretario);
		gestao.setEmailViceDiretor(emailViceDiretor);
		gestao.setFaxDiretor(faxDiretor);
		gestao.setFaxSecretarioGf(faxSecretarioGf);
		gestao.setFaxViceDiretor(faxViceDiretor);
		gestao.setNomeCentro(nomeCentro);
		gestao.setNomeDiretor(nomeDiretor);
		gestao.setNomeSecretarioGf(nomeSecretarioGf);
		gestao.setNomeViceDiretor(nomeViceDiretor);
		gestao.setSenhaUsuario(senhaUsuario);
		gestao.setSiglaCentro(siglaCentro);
		gestao.setTelefoneDiretor(telefoneDiretor);
		gestao.setTelefoneSecretarioGf(telefoneSecretarioGf);
		gestao.setTelefoneViceDiretor(telefoneViceDiretor);
		gestao.setTexto(texto);

		cadGestao.salvaGestao(gestao);
	}


	public void removeGestao(int codGestao ) throws Exception{
		Gestao gestao = procurarGestao(codGestao);
		if (gestao == null)
			throw new Exception("gestao nao encontrado.");
		else
			cadGestao.removeGestao(gestao);
	}

	public void removeGestao(String nomeCentro) throws Exception{
		Gestao gestao = procurarGestao(nomeCentro);
		if (gestao == null)
			throw new Exception("gestao nao encontrado.");
		else
			cadGestao.removeGestao(gestao);
	}

	public Gestao procurarGestao(int codGestao ) {
		List<Gestao> listaGestao = cadGestao.getListaDeGestao();
		for (Gestao gestao : listaGestao) {
			if (gestao.getCodigoGestao() != -1)
				if (gestao.getCodigoGestao() == codGestao ) {
					return gestao; 
				}
		}
		return null;
	}


	public Gestao procurarGestao(String nomeGestao) {
		List<Gestao> listaGestao = cadGestao.getListaDeGestao();
		for (Gestao gestao : listaGestao) {
			if (gestao.getNomeCentro() != null)
				if (gestao.getNomeCentro().equals(nomeGestao)) {
					return gestao; 
				}
		}
		return null;
	}




	public void removeTodosGestaos() {
		List<Gestao> listaGestaos = cadGestao.getListaDeGestao();
		for (Gestao gestao : listaGestaos) {
			cadGestao.removeGestao(gestao);
		}
	}




	public void atualizaGestao(int codigoGestao,String nomeCentro
			,String nomeDiretor, String nomeViceDiretor, String siglaCentro
			, String nomeSecretarioGf, String emailDiretor,String emailViceDiretor
			, String emailSecretario, String texto, String ativa 
			, String faxDiretor, String faxViceDiretor, String faxSecretarioGf
			, String telefoneDiretor, String telefoneViceDiretor, String telefoneSecretarioGf
			, String celularDiretor, String celularViceDiretor, String celularSecretarioGf
			, String senhaUsuario	 ) {

		Gestao gestao = procurarGestao(nomeCentro);

		gestao.setAtiva(ativa);
		gestao.setCelularDiretor(celularDiretor);
		gestao.setCelularSecretarioGf(celularSecretarioGf);
		gestao.setCelularViceDiretor(celularViceDiretor);
		gestao.setCodigoGestao(codigoGestao);
		gestao.setEmailDiretor(emailDiretor);
		gestao.setEmailSecretario(emailSecretario);
		gestao.setEmailViceDiretor(emailViceDiretor);
		gestao.setFaxDiretor(faxDiretor);
		gestao.setFaxSecretarioGf(faxSecretarioGf);
		gestao.setFaxViceDiretor(faxViceDiretor);
		gestao.setNomeCentro(nomeCentro);
		gestao.setNomeDiretor(nomeDiretor);
		gestao.setNomeSecretarioGf(nomeSecretarioGf);
		gestao.setNomeViceDiretor(nomeViceDiretor);
		gestao.setSenhaUsuario(senhaUsuario);
		gestao.setSiglaCentro(siglaCentro);
		gestao.setTelefoneDiretor(telefoneDiretor);
		gestao.setTelefoneSecretarioGf(telefoneSecretarioGf);
		gestao.setTelefoneViceDiretor(telefoneViceDiretor);
		gestao.setTexto(texto);	

		cadGestao.atualizarGestao(gestao);
	}



	public Gestao getGestao(int cod) {
		return cadGestao.getGestao(cod);
	}

	public List<Gestao> getListaDeGestao() {
		return cadGestao.getListaDeGestao();
	}

	public String getAtributoGestao(int codGestao, String atributo) throws Exception {
		Gestao gestao = procurarGestao(codGestao);
		if(gestao != null){
			/*int codigoGestao,String nomeCentro
			,String nomeDiretor, String nomeViceDiretor, String siglaCentro
			, String nomeSecretarioGf, String emailDiretor,String emailViceDiretor
			, String emailSecretario, String texto, String ativa 
			, String faxDiretor, String faxViceDiretor, String faxSecretarioGf
			, String telefoneDiretor, String telefoneViceDiretor, String telefoneSecretarioGf
			, String celularDiretor, String celularViceDiretor, String celularSecretarioGf
			, String senhaUsuario	
			 */		
			if (atributo.equals("nomeCentro")) 
				return gestao.getNomeCentro();
			else if (atributo.equals("nomeDiretor"))
				return gestao.getNomeDiretor();
			else if (atributo.equals("nomeViceDiretor"))
				return gestao.getNomeViceDiretor();
			else if (atributo.equals("siglaCentro"))
				return gestao.getSiglaCentro();
			else if (atributo.equals("nomeSecretarioGf"))
				return gestao.getNomeSecretarioGf();
			else if (atributo.equals("emailDiretor"))
				return gestao.getEmailDiretor();
			else if (atributo.equals("emailViceDiretor"))
				return gestao.getEmailViceDiretor();
			else if (atributo.equals("emailViceDiretor"))
				return gestao.getEmailSecretario();
			else if (atributo.equals("texto"))
				return gestao.getTexto();
			else if (atributo.equals("ativa"))
				return gestao.getAtiva();
			else if (atributo.equals("faxDiretor"))
				return gestao.getFaxDiretor();
			else if (atributo.equals("faxViceDiretor"))
				return gestao.getFaxViceDiretor();
			else if (atributo.equals("faxSecretarioGf"))
				return gestao.getFaxSecretarioGf();
			else if (atributo.equals("telefoneDiretor"))
				return gestao.getTelefoneDiretor();
			else if (atributo.equals("telefoneViceDiretor"))
				return gestao.getTelefoneViceDiretor();
			else if (atributo.equals("telefoneSecretarioGf"))
				return gestao.getTelefoneSecretarioGf();

			else if (atributo.equals("celularDiretor"))
				return gestao.getCelularDiretor();
			else if (atributo.equals("celularViceDiretor"))
				return gestao.getCelularViceDiretor();
			else if (atributo.equals("celularSecretarioGf"))
				return gestao.getCelularSecretarioGf();
			else if (atributo.equals("senhaUsuario"))
				return gestao.getSenhaUsuario();

			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("Gestao nao encontrado.");
	}	



	// TABELA 4 MOV DEPARTAMENTO

	public void cadastrarMovDepartamento
	(int codigoMovDepartamento,int usuariosCodigo
			, int codigoGestao,  int codigoDepartamento
			, int codigoRubrica ,int codigoTipoMovimento
			, int codigoChegadaRecurso, float valorMovDepartamento
			,String texto,Date dataMovimentacao
			,int usuarioMovimentacao) {
		MovDepartamento movDep = new MovDepartamento();

		movDep.setCodigoChegadaRecurso(codigoChegadaRecurso);
		movDep.setCodigoDepartamento(codigoDepartamento);
		movDep.setCodigoGestao(codigoGestao);
		movDep.setCodigoMovDepartamento(codigoMovDepartamento);
		movDep.setCodigoRubrica(codigoRubrica);
		movDep.setCodigoTipoMovimento(codigoTipoMovimento);
		movDep.setDataMovimentacao(dataMovimentacao);
		movDep.setTexto(texto);
		movDep.setUsuarioMovimentacao(usuarioMovimentacao);
		movDep.setUsuariosCodigo(usuariosCodigo);
		movDep.setValorMovDepartamento(valorMovDepartamento);

		cadMovDepto.salvaMovDepartamento(movDep);		
	}



	public void removeMovDepartamento(int cod ) throws Exception {
		MovDepartamento movDev = procurarMovDepartamento(cod);
		if(movDev == null)
			throw new Exception("MovDepartamento nao encontrado.");
		else 
			cadMovDepto.removeMovDepartamento(movDev);
	}


	public void removeTodosMovDepartamentos(){
		List<MovDepartamento> listaDeMovDepartamentos = cadMovDepto.getListaDeMovDepartamento();
		for (MovDepartamento movDep : listaDeMovDepartamentos) {
			cadMovDepto.removeMovDepartamento(movDep);
		}
	}


	public void atualizarMovDepartamento(int codigoMovDepartamento,int usuariosCodigo
			, int codigoGestao,  int codigoDepartamento
			, int codigoRubrica ,int codigoTipoMovimento
			, int codigoChegadaRecurso, float valorMovDepartamento
			,String texto,Date dataMovimentacao
			,int usuarioMovimentacao ) {

		MovDepartamento movDep = procurarMovDepartamento(codigoMovDepartamento);

		movDep.setCodigoChegadaRecurso(codigoChegadaRecurso);
		movDep.setCodigoDepartamento(codigoDepartamento);
		movDep.setCodigoGestao(codigoGestao);
		movDep.setCodigoMovDepartamento(codigoMovDepartamento);
		movDep.setCodigoRubrica(codigoRubrica);
		movDep.setCodigoTipoMovimento(codigoTipoMovimento);
		movDep.setDataMovimentacao(dataMovimentacao);
		movDep.setTexto(texto);
		movDep.setUsuarioMovimentacao(usuarioMovimentacao);
		movDep.setUsuariosCodigo(usuariosCodigo);
		movDep.setValorMovDepartamento(valorMovDepartamento);

		cadMovDepto.atualizarMovDepartamento(movDep);
	}




	public MovDepartamento getMovDepartamento(int cod) {
		return cadMovDepto.getMovDepartamento(cod);
	}


	public List<MovDepartamento> getListaDeMovDepartamentos() {
		return cadMovDepto.getListaDeMovDepartamento();
	}




	public MovDepartamento procurarMovDepartamento(int cod ) {
		List<MovDepartamento> listaMovDepartamento = cadMovDepto.getListaDeMovDepartamento();
		for (MovDepartamento movDev : listaMovDepartamento) {
			if (movDev.getCodigoChegadaRecurso()  !=  -1) {
				if (movDev.getCodigoChegadaRecurso() == cod ) {
					return movDev; 
				}
			}
		}
		return null;
	}









	// TABELA 5	  MOV GESTAO

	public void cadastrarMovGestao
	(int codigoMovGestao,int usuariosCodigo
			, int codigoRubrica,int codigoGestao
			, int codigoDepartamento, int codigoTipoMovimento
			, int codigoChegadaRecurso, float valorMovGestao
			,String texto,Date dataMovimentacao
			,int usuarioMovimentacao) {
		MovGestao movGestao = new MovGestao();

		movGestao.setCodigoChegadaRecurso(codigoChegadaRecurso);
		movGestao.setCodigoDepartamento(codigoDepartamento);
		movGestao.setCodigoGestao(codigoGestao);
		movGestao.setCodigoRubrica(codigoRubrica);
		movGestao.setCodigoTipoMovimento(codigoTipoMovimento);
		movGestao.setCodMovGestao(codigoMovGestao);
		movGestao.setDataMovimentacao(dataMovimentacao);
		movGestao.setTexto(texto);
		movGestao.setUsuarioMovimentacao(usuarioMovimentacao);
		movGestao.setUsuariosCodigo(usuariosCodigo);
		movGestao.setValorMovGestao(valorMovGestao);

		cadMovGestao.salvaMovGestao(movGestao);
	}



	public void removeMovGestao(int cod ) throws Exception {
		MovGestao movDev = procurarMovGestao(cod);
		if(movDev == null)
			throw new Exception("MovGestao nao encontrado.");
		else 
			cadMovGestao.removeMovGestao(movDev);
	}


	public void removeTodosMovGestaos(){
		List<MovGestao> listaDeMovGestaos = cadMovGestao.getListaDeMovGestao();
		for (MovGestao movDep : listaDeMovGestaos) {
			cadMovGestao.removeMovGestao(movDep);
		}
	}


	public void atualizarMovGestao(int codigoMovGestao,int usuariosCodigo
			, int codigoGestao,  int codigoDepartamento
			, int codigoRubrica ,int codigoTipoMovimento
			, int codigoChegadaRecurso, float valorMovGestao
			,String texto,Date dataMovimentacao
			,int usuarioMovimentacao ) {

		MovGestao movDep = procurarMovGestao(codigoMovGestao);

		movDep.setCodigoChegadaRecurso(codigoChegadaRecurso);
		movDep.setCodigoDepartamento(codigoDepartamento);
		movDep.setCodigoGestao(codigoGestao);
		movDep.setCodMovGestao(codigoMovGestao);
		movDep.setCodigoRubrica(codigoRubrica);
		movDep.setCodigoTipoMovimento(codigoTipoMovimento);
		movDep.setDataMovimentacao(dataMovimentacao);
		movDep.setTexto(texto);
		movDep.setUsuarioMovimentacao(usuarioMovimentacao);
		movDep.setUsuariosCodigo(usuariosCodigo);
		movDep.setValorMovGestao(valorMovGestao);

		cadMovGestao.atualizarMovGestao(movDep);
	}




	public MovGestao getMovGestao(int cod) {
		return cadMovGestao.getMovGestao(cod);
	}


	public List<MovGestao> getListaDeMovGestaos() {
		return cadMovGestao.getListaDeMovGestao();
	}




	public MovGestao procurarMovGestao(int cod ) {
		List<MovGestao> listaMovGestao = cadMovGestao.getListaDeMovGestao();
		for (MovGestao movGestao : listaMovGestao) {
			if (movGestao.getCodMovGestao()!=  -1) {
				if (movGestao.getCodMovGestao() == cod ) {
					return movGestao; 
				}
			}
		}
		return null;
	}









	// TABELA 6 PERMISSOES
	/*
	private int codigo; //PRIMARY KEY{CODIGO},
	private int usuariosCodigo; 
	private int usuario; 
	private String permissao; 
	 */
	public void cadastrarPermissoes
	(int codigo,int usuariosCodigo
			, int usuario,  String permissao ) {

		Permissoes permis = new Permissoes();

		permis.setId(codigo);
		permis.setPermissao(permissao);
		permis.setUsuario(usuario);
		permis.setUsuariosCodigo(usuariosCodigo);

		cadPermissoes.salvaPermissoes(permis);
	}



	public void removePermissoes(int cod ) throws Exception {
		Permissoes permissoes = procurarPermissoes(cod);
		if(permissoes == null)
			throw new Exception("Permissoes nao encontrado.");
		else 
			cadPermissoes.removePermissoes(permissoes);
	}


	public void removeTodosPermissoess(){
		List<Permissoes> listaDePermissoess = cadPermissoes.getListaDePermissoes();
		for (Permissoes permis : listaDePermissoess) {
			cadPermissoes.removePermissoes(permis);
		}
	}


	public void atualizarPermissoes(int codigoPermissoes
			,int usuariosCodigo, int usuario,  String permissao ) {

		Permissoes permis = procurarPermissoes(codigoPermissoes);

		permis.setId(codigoPermissoes);
		permis.setPermissao(permissao);
		permis.setUsuario(usuario);
		permis.setUsuariosCodigo(usuariosCodigo);

		cadPermissoes.atualizarPermissoes(permis);
	}


	public Permissoes getPermissoes(int cod) {
		return cadPermissoes.getPermissoes(cod);
	}

	public List<Permissoes> getListaDePermissoess() {
		return cadPermissoes.getListaDePermissoes();
	}

	public Permissoes procurarPermissoes(int cod ) {
		List<Permissoes> listaPermissoes = cadPermissoes.getListaDePermissoes();
		for (Permissoes permiss : listaPermissoes) {
			if (permiss.getId()  !=  -1) {
				if (permiss.getId() == cod ) {
					return permiss; 
				}
			}
		}
		return null;
	}




	//TABELA 7 RUBRICA

	/*
	private int codigoRubrica;         //PRIMARY KEY{CODIGO_RUBRICA}
	private String nomeRubrica;
	private String codigoMec;
	private float porcentagem; // NUMERIC{9,4} ,
	 */
	public void cadastrarRubrica
	(int codigoRubrica,String nomeRubrica
			, String codigoMec,  float porcentagem ) {

		Rubrica rubrica = new Rubrica();

		rubrica.setCodigoMec(codigoMec);
		rubrica.setId(codigoRubrica);
		rubrica.setNomeRubrica(nomeRubrica);
		rubrica.setPorcentagem(porcentagem);

		cadRubrica.salvaRubrica(rubrica);
	}



	public void removeRubrica(int cod ) throws Exception {
		Rubrica rubrica = procurarRubrica(cod);
		if(rubrica == null)
			throw new Exception("Rubrica nao encontrado.");
		else 
			cadRubrica.removeRubrica(rubrica);
	}

	public void removeRubrica(String nomeRubrica) throws Exception {
		Rubrica rubrica = procurarRubrica(nomeRubrica);
		if(rubrica == null)
			throw new Exception("Rubrica nao encontrado.");
		else 
			cadRubrica.removeRubrica(rubrica);
	}


	public void removeTodosRubricas(){
		List<Rubrica> listaDeRubricas = cadRubrica.getListaDeRubrica();
		for (Rubrica rubrica : listaDeRubricas) {
			cadRubrica.removeRubrica(rubrica);
		}
	}


	public void atualizarRubrica(
			int codigoRubrica,String nomeRubrica
			, String codigoMec,  float porcentagem ) {

		Rubrica rubrica = procurarRubrica(codigoRubrica);

		rubrica.setCodigoMec(codigoMec);
		rubrica.setId(codigoRubrica);
		rubrica.setNomeRubrica(nomeRubrica);
		rubrica.setPorcentagem(porcentagem);


		cadRubrica.atualizarRubrica(rubrica);
	}


	public Rubrica getRubrica(int cod) {
		return cadRubrica.getRubrica(cod);
	}

	public List<Rubrica> getListaDeRubricas() {
		return cadRubrica.getListaDeRubrica();
	}

	public Rubrica procurarRubrica(int codRubrica ) {
		List<Rubrica> listaRubrica = cadRubrica.getListaDeRubrica();
		for (Rubrica rubricas : listaRubrica) {
			if (rubricas.getId()  !=  -1) {
				if (rubricas.getId() == codRubrica ) {
					return rubricas; 
				}
			}
		}
		return null;
	}

	public Rubrica procurarRubrica(String nomeRubrica) {
		List<Rubrica> listaRubrica = cadRubrica.getListaDeRubrica();
		for (Rubrica rubrica : listaRubrica) {
			if (rubrica.getNomeRubrica() != null)
				if (rubrica.getNomeRubrica().equals(nomeRubrica)) {
					return rubrica; 
				}
		}
		return null;
	}





	public String getAtributoRubrica(int codigoRubrica
			, String atributo ) throws Exception {

		Rubrica rubrica = procurarRubrica(codigoRubrica);

		if(rubrica != null){
			if (atributo.equals("nomeRubrica")) 
				return rubrica.getNomeRubrica();
			else if (atributo.equals("codigoMec"))
				return rubrica.getCodigoMec();
			else if (atributo.equals("percentagem"))
				return String.valueOf( rubrica.getPorcentagem() );
			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("Rubrica nao encontrado.");
	}





	// TABELA 8 RUBRICA DEPARTAMENTO

	/*
	private int id; 
	private int codigoDepartamento;
	private int codigoRubrica;
	private float porcentagem; //PORCENTAGEM NUMERIC{9,4} ,
	 */
	public void cadastrarRubricaDepartamento
	(int id, int codigoDepartamento
			, int codigoRubrica,  float porcentagem ) {

		RubricaDepartamento rubricaDep = new RubricaDepartamento();

		rubricaDep.setCodigoDepartamento(codigoDepartamento) ;
		rubricaDep.setCodigoRubrica(codigoRubrica) ;
		rubricaDep.setId(id) ;
		rubricaDep.setPorcentagem(porcentagem) ;

		cadRubDepto.salvaRubricaDepartamento(rubricaDep);
	}



	public void removeRubricaDepartamento(int cod ) throws Exception {
		RubricaDepartamento rubricaDep = procurarRubricaDepartamento(cod);
		if(rubricaDep == null)
			throw new Exception("RubricaDepartamento nao encontrado.");
		else 
			cadRubDepto.removeRubricaDepartamento(rubricaDep);
	}


	public void removeTodosRubricaDepartamentos(){
		List<RubricaDepartamento> listaDeRubricaDepartamentos = cadRubDepto.getListaDeRubricaDepartamento();
		for (RubricaDepartamento rubricaDep : listaDeRubricaDepartamentos) {
			cadRubDepto.removeRubricaDepartamento(rubricaDep);
		}
	}


	public void atualizarRubricaDepartamento(
			int id, int codigoDepartamento,
			int codigoRubrica,  float porcentagem ) {

		RubricaDepartamento rubricaDep = procurarRubricaDepartamento(id);

		rubricaDep.setCodigoDepartamento(codigoDepartamento) ;
		rubricaDep.setCodigoRubrica(codigoRubrica) ;
		rubricaDep.setId(id) ;
		rubricaDep.setPorcentagem(porcentagem) ;

		cadRubDepto.atualizarRubricaDepartamento(rubricaDep);
	}


	public RubricaDepartamento getRubricaDepartamento(int cod) {
		return cadRubDepto.getRubricaDepartamento(cod);
	}

	public List<RubricaDepartamento> getListaDeRubricaDepartamentos() {
		return cadRubDepto.getListaDeRubricaDepartamento();
	}

	public RubricaDepartamento procurarRubricaDepartamento(int codRubricaDepartamento ) {
		List<RubricaDepartamento> listaRubricaDepartamento = cadRubDepto.getListaDeRubricaDepartamento();
		for (RubricaDepartamento rubricaDeps : listaRubricaDepartamento) {
			if (rubricaDeps.getId()  !=  -1) {
				if (rubricaDeps.getId() == codRubricaDepartamento ) {
					return rubricaDeps; 
				}
			}
		}
		return null;
	}


	public String getAtributoRubricaDepartamento(int codigoRubricaDepartamento
			, String atributo ) throws Exception {

		RubricaDepartamento rubricaDep = procurarRubricaDepartamento(codigoRubricaDepartamento);

		if(rubricaDep != null){
			if (atributo.equals("codigoDepartamento")) 
				return String.valueOf( rubricaDep.getCodigoDepartamento()  );
			else if (atributo.equals("codigoRubrica"))
				return String.valueOf( rubricaDep.getCodigoRubrica() );
			else if (atributo.equals("percentagem"))
				return String.valueOf( rubricaDep.getPorcentagem() );
			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("RubricaDepartamento nao encontrado.");
	}





	// TABELA 9 TIPO MOVIMENTO


	/*
private int codigoTipoMovimento; // PRIMARY KEY{CODIGO_TIPO_MOVIMENTO}
	private String descricao; 	
	 */
	public void cadastrarTipoMovimento
	(int codigoTipoMovimento , String  descricao ) {

		TipoMovimento tipoMov = new TipoMovimento();

		tipoMov.setId(codigoTipoMovimento);
		tipoMov.setDescricao(descricao);

		cadTipoMov.salvaTipoMovimento(tipoMov);
	}



	public void removeTipoMovimento(int cod ) throws Exception {
		TipoMovimento tipoMov = procurarTipoMovimento(cod);
		if(tipoMov == null)
			throw new Exception("TipoMovimento nao encontrado.");
		else 
			cadTipoMov.removeTipoMovimento(tipoMov);
	}
	public void removeTipoMovimento(String descricao ) throws Exception {
		TipoMovimento tipoMov = procurarTipoMovimento(descricao);
		if(tipoMov == null)
			throw new Exception("TipoMovimento nao encontrado.");
		else 
			cadTipoMov.removeTipoMovimento(tipoMov);
	}


	public void removeTodosTipoMovimentos(){
		List<TipoMovimento> listaDeTipoMovimentos = cadTipoMov.getListaDeTipoMovimento();
		for (TipoMovimento tipoMov : listaDeTipoMovimentos) {
			cadTipoMov.removeTipoMovimento(tipoMov);
		}
	}


	public void atualizarTipoMovimento(
			int codigoTipoMovimento , String  descricao ) {

		TipoMovimento tipoMov = procurarTipoMovimento(codigoTipoMovimento);

		tipoMov.setId(codigoTipoMovimento);
		tipoMov.setDescricao(descricao);

		cadTipoMov.atualizarTipoMovimento(tipoMov);
	}


	public TipoMovimento getTipoMovimento(int cod) {
		return cadTipoMov.getTipoMovimento(cod);
	}

	public List<TipoMovimento> getListaDeTipoMovimentos() {
		return cadTipoMov.getListaDeTipoMovimento();
	}

	public TipoMovimento procurarTipoMovimento(int codTipoMovimento ) {
		List<TipoMovimento> listaTipoMovimento = cadTipoMov.getListaDeTipoMovimento();
		for (TipoMovimento tipoMov : listaTipoMovimento) {
			if (tipoMov.getId()  !=  -1) {
				if (tipoMov.getId() == codTipoMovimento ) {
					return tipoMov; 
				}
			}
		}
		return null;
	}

	public TipoMovimento procurarTipoMovimento(String descricao) {
		List<TipoMovimento> listaTipoMovimento = cadTipoMov.getListaDeTipoMovimento();
		for (TipoMovimento tipoMov : listaTipoMovimento) {
			if (tipoMov.getDescricao() != null)
				if (tipoMov.getDescricao().equals(descricao)) {
					return tipoMov; 
				}
		}
		return null;
	}


	public String getAtributoTipoMovimento(int codigoTipoMovimento
			, String atributo ) throws Exception {

		TipoMovimento tipoMov = procurarTipoMovimento(codigoTipoMovimento);

		if(tipoMov != null){
			if (atributo.equals("codigoTipoMovimento")) 
				return String.valueOf( tipoMov.getId()  );
			else if (atributo.equals("descricao"))
				return String.valueOf( tipoMov.getDescricao() );
			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("TipoMovimento nao encontrado.");
	}









	// TABELA 10  TIPO TRANSFERENCIA

	/*
private int codigoTipoTransferencia;
private String descricao; 

	 */
	public void cadastrarTipoTransferencia
	(int codigoTipoTransferencia , String  descricao ) {

		TipoTransferencia tipoTrans = new TipoTransferencia();

		tipoTrans.setId(codigoTipoTransferencia);
		tipoTrans.setDescricao(descricao);

		cadTipoTrans.salvaTipoTransferencia(tipoTrans);
	}



	public void removeTipoTransferencia(int cod ) throws Exception {
		TipoTransferencia tipoTrans = procurarTipoTransferencia(cod);
		if(tipoTrans == null)
			throw new Exception("TipoTransferencia nao encontrado.");
		else 
			cadTipoTrans.removeTipoTransferencia(tipoTrans);
	}
	public void removeTipoTransferencia(String descricao ) throws Exception {
		TipoTransferencia tipoTrans = procurarTipoTransferencia(descricao);
		if(tipoTrans == null)
			throw new Exception("TipoTransferencia nao encontrado.");
		else 
			cadTipoTrans.removeTipoTransferencia(tipoTrans);
	}


	public void removeTodosTipoTransferencias(){
		List<TipoTransferencia> listaDeTipoTransferencias = cadTipoTrans.getListaDeTipoTransferencia();
		for (TipoTransferencia tipoTrans : listaDeTipoTransferencias) {
			cadTipoTrans.removeTipoTransferencia(tipoTrans);
		}
	}


	public void atualizarTipoTransferencia(
			int codigoTipoTransferencia , String  descricao ) {

		TipoTransferencia tipoTrans = procurarTipoTransferencia(codigoTipoTransferencia);

		tipoTrans.setId(codigoTipoTransferencia);
		tipoTrans.setDescricao(descricao);

		cadTipoTrans.atualizarTipoTransferencia(tipoTrans);
	}


	public TipoTransferencia getTipoTransferencia(int cod) {
		return cadTipoTrans.getTipoTransferencia(cod);
	}

	public List<TipoTransferencia> getListaDeTipoTransferencias() {
		return cadTipoTrans.getListaDeTipoTransferencia();
	}

	public TipoTransferencia procurarTipoTransferencia(int codTipoTransferencia ) {
		List<TipoTransferencia> listaTipoTransferencia = cadTipoTrans.getListaDeTipoTransferencia();
		for (TipoTransferencia tipoTrans : listaTipoTransferencia) {
			if (tipoTrans.getId()  !=  -1) {
				if (tipoTrans.getId() == codTipoTransferencia ) {
					return tipoTrans; 
				}
			}
		}
		return null;
	}

	public TipoTransferencia procurarTipoTransferencia(String descricao) {
		List<TipoTransferencia> listaTipoTransferencia = cadTipoTrans.getListaDeTipoTransferencia();
		for (TipoTransferencia tipoTrans : listaTipoTransferencia) {
			if (tipoTrans.getDescricao() != null)
				if (tipoTrans.getDescricao().equals(descricao)) {
					return tipoTrans; 
				}
		}
		return null;
	}


	public String getAtributoTipoTransferencia(int codigoTipoTransferencia
			, String atributo ) throws Exception {

		TipoTransferencia tipoTrans = procurarTipoTransferencia(codigoTipoTransferencia);

		if(tipoTrans != null){
			if (atributo.equals("codigoTipoTransferencia")) 
				return String.valueOf( tipoTrans.getId()  );
			else if (atributo.equals("descricao"))
				return String.valueOf( tipoTrans.getDescricao() );
			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("TipoTransferencia nao encontrado.");
	}





	// TABELA 11  TRANSFERENCIA 

	public void cadastrarTransferencia
	(		int codigoTransferencia, int codigoGestao, int codigoOrigem,
			int codigoDestino , int codigoTipoTransferencia ,
			String motivo, float valorTransferencia  ) {

		Transferencia trans = new Transferencia();

		trans.setCodigoDestino(codigoDestino);
		trans.setCodigoGestao(codigoGestao);
		trans.setCodigOrigem(codigoOrigem);
		trans.setCodigoTipoTransferencia(codigoTipoTransferencia);
		trans.setId(codigoTransferencia);
		trans.setMotivo(motivo);
		trans.setValorTransferencia(valorTransferencia);

		cadTrans.salvaTransferencia(trans);
	}



	public void removeTransferencia(int codigoTransferencia ) throws Exception {
		Transferencia trans = procurarTransferencia(codigoTransferencia);
		if(trans == null)
			throw new Exception("Transferencia nao encontrado.");
		else 
			cadTrans.removeTransferencia(trans);
	}


	public void removeTodosTransferencias(){
		List<Transferencia> listaDeTransferencias = cadTrans.getListaDeTransferencia();
		for (Transferencia trans : listaDeTransferencias) {
			cadTrans.removeTransferencia(trans);
		}
	}


	public void atualizarTransferencia(
			int codigoTransferencia, int codigoGestao, int codigoOrigem,
			int codigoDestino , int codigoTipoTransferencia ,
			String motivo, float valorTransferencia ) {

		Transferencia trans = procurarTransferencia(codigoTransferencia);

		trans.setCodigoDestino(codigoDestino);
		trans.setCodigoGestao(codigoGestao);
		trans.setCodigOrigem(codigoOrigem);
		trans.setCodigoTipoTransferencia(codigoTipoTransferencia);
		trans.setId(codigoTransferencia);
		trans.setMotivo(motivo);
		trans.setValorTransferencia(valorTransferencia);

		cadTrans.atualizarTransferencia(trans);
	}


	public Transferencia getTransferencia(int codigoTransferencia) {
		return cadTrans.getTransferencia(codigoTransferencia);
	}

	public List<Transferencia> getListaDeTransferencias() {
		return cadTrans.getListaDeTransferencia();
	}

	public Transferencia procurarTransferencia(int codigoTransferencia ) {
		List<Transferencia> listaTransferencia = cadTrans.getListaDeTransferencia();
		for (Transferencia trans : listaTransferencia) {
			if (trans.getId()  !=  -1) {
				if (trans.getId() == codigoTransferencia ) {
					return trans; 
				}
			}
		}
		return null;
	}

	public String getAtributoTransferencia(int codigoTransferencia
			, String atributo ) throws Exception {

		Transferencia trans = procurarTransferencia(codigoTransferencia);

		if(trans != null){
			if (atributo.equals("codigoTransferencia")) 
				return String.valueOf( trans.getId()  );
			else if (atributo.equals("codigoGestao"))
				return String.valueOf( trans.getCodigoGestao() );
			else if (atributo.equals("codigoOrigem"))
				return String.valueOf( trans.getCodigoOrigem() );
			else if (atributo.equals("codigoDestino"))
				return String.valueOf( trans.getcodigoDestino() );
			else if (atributo.equals("codigoTipoTransferencia"))
				return String.valueOf( trans.getCodigoTipoTransferencia() );
			else if (atributo.equals("motivo"))
				return  trans.getMotivo();
			else if (atributo.equals("valorTransferencia"))
				return String.valueOf( trans.getValorTransferencia() );

			else
				throw new AtributoInvalidoException("Atributo inv�lido.");
		} else 
			throw new Exception("Transferencia nao encontrado.");
	}





	// TABELA 12  USUARIOS
	
	/*
private int codigo; //  PRIMARY KEY{CODIGO}
private String nome; 
private String login;
private String senha;
private String libera;
private String exclui;
	 */
	public void cadastrarUsuarios(
			int codigo,String nome, String login, String senha,
			String libera, String exclui ) {
		Usuarios usuario = new Usuarios();

		usuario.setExclui(exclui);
		usuario.setId(codigo);
		usuario.setLibera(libera);
		usuario.setLogin(login);
		usuario.setNome(nome);
		usuario.setSenha(senha);
				
		cadUsuarios.salvaUsuarios(usuario);		
	}



	public void removeUsuarios(int cod ) throws Exception {
		Usuarios usuario = procurarUsuarios(cod);
		if(usuario == null)
			throw new Exception("Usuarios nao encontrado.");
		else 
			cadUsuarios.removeUsuarios(usuario);
	}


	public void removeTodosUsuarios(){
		List<Usuarios> listaDeUsuarioss = cadUsuarios.getListaDeUsuarios();
		for (Usuarios usuario : listaDeUsuarioss) {
			cadUsuarios.removeUsuarios(usuario);
		}
	}


	public void atualizarUsuarios(
			int codigo,String nome, String login, String senha,
			String libera, String exclui ) {

		Usuarios usuario = procurarUsuarios(codigo);

		usuario.setExclui(exclui);
		usuario.setId(codigo);
		usuario.setLibera(libera);
		usuario.setLogin(login);
		usuario.setNome(nome);
		usuario.setSenha(senha);
				
		cadUsuarios.atualizarUsuarios(usuario);
	}




	public Usuarios getUsuarios(int cod) {
		return cadUsuarios.getUsuarios(cod);
	}


	public List<Usuarios> getListaDeUsuarioss() {
		return cadUsuarios.getListaDeUsuarios();
	}


	public Usuarios procurarUsuarios(int cod ) {
		List<Usuarios> listaUsuarios = cadUsuarios.getListaDeUsuarios();
		for (Usuarios usuario : listaUsuarios) {
			if (usuario.getId()  !=  -1) {
				if (usuario.getId() == cod ) {
					return usuario; 
				}
			}
		}
		return null;
	}


	public Usuarios procurarUsuarios(String nome) {
		List<Usuarios> listaUsuarios = cadUsuarios.getListaDeUsuarios();
		for (Usuarios usuario : listaUsuarios) {
			if (usuario.getNome() != null)
				if (usuario.getNome().equals(nome)) {
					return usuario; 
				}
		}
		return null;
	}

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//////////////////  FIM DAS TABELAS   ///////////////////////////////
	
	
	
	/**
	 * encerra o sistema
	 */
	public void encerrarSistema() {}





//	public void encerrarSistema() {}
//
//
//	public void gerarRelatorio(String tipo) throws IOException {
//		if (tipo.equalsIgnoreCase("relatorioControleDeCaixa")){
//			Runtime.getRuntime().exec("java -jar RelatorioCaixa.jar");
//		} else if(tipo.equalsIgnoreCase("relatorioControleDeEstoque")){
//			Runtime.getRuntime().exec("java -jar RelatorioEstoque.jar");
//		}
//	}	
} // fim da classe XModel
